How to Run Sage A1.5 Locally with llama.cpp
A practical guide to running Sage A1.5, the 35B MoE agentic model, locally with llama.cpp, covering VRAM use and context window tradeoffs.
What is Sage A1.5 and why run it locally?
Sage A1.5 is a 35 billion parameter mixture of experts model built by Intern, the Shanghai-based lab behind the earlier Agent A1 model. It’s trained on top of Qwen 3.6 and tuned specifically for long, multi-step agentic work rather than one-shot answers. That means it splits tasks across sub agents, checks its own evidence mid-reasoning, and course-corrects when its output disagrees with expected results. Running it locally through llama.cpp matters because its mixture-of-experts design keeps active VRAM use low enough to fit on a single high-end consumer or prosumer GPU, something most 35B-class dense models can’t manage.
TL;DR
- Sage A1.5 is a 35B parameter mixture-of-experts model from Intern, built on Qwen 3.6, aimed at agentic research, scientific analysis, and software engineering tasks.
- Local VRAM usage came in around 38GB when served through llama.cpp in testing, which is realistic for a single 48GB class GPU or a dual-GPU consumer setup.
- Context window size directly trades against VRAM, so shrinking the context is the simplest lever for squeezing the model onto smaller cards.
- Training happens in two stages: separate teacher models are built for domains like long-horizon search, engineering, and science, then merged into one model using reward signals plus on-policy distillation.
- The model architecture adds two execution layers on top of domain skills: orchestration (delegating work to parallel sub agents) and verification (checking its own reasoning and adjusting course).
- Hands-on testing showed accurate physics simulation, successful parallel sub-agent delegation, and controlled hallucination, with the model explicitly flagging what it couldn’t verify.
- Benchmark claims put it ahead of several larger named models in its class, though those numbers should be treated as a starting point, not a substitute for testing your own workloads.
- Name
- Maria Alvarez
- Date of birth
- SSN
- Diagnosis
- Balance due
- $412.80
How much VRAM does Sage A1.5 need?
In local testing with llama.cpp, Sage A1.5 ran at approximately 38GB of VRAM. That figure is notable for a 35B parameter model because mixture-of-experts architectures don’t activate all parameters per token, which keeps memory and compute demands lower than a dense model of the same nominal size. A 38GB footprint fits comfortably on a single 48GB GPU (like an RTX 6000 Ada or A6000) with headroom to spare, and it’s within reach of dual 24GB consumer cards (two RTX 4090s or 3090s) running in tandem.
The exact number you see will depend on quantization level, context length, and which llama.cpp build and backend you use. The 38GB figure reflects one configuration tested directly, not a hard spec from Intern’s own documentation, so treat it as a practical reference point rather than a guarantee.
How does the context window affect resource use?
Context window size is the most direct lever for controlling VRAM consumption once you’ve settled on a quantization format. Longer context windows mean more KV cache held in memory, which adds up fast on a model designed for long, multi-step agentic tasks where the model is reasoning across many tool calls and sub-agent outputs.
If you’re VRAM-constrained, lowering the context window is the simplest way to bring usage down further than the 38GB baseline. The tradeoff is real: Sage A1.5 is built for long-horizon work, orchestrating sub agents and holding onto intermediate reasoning and verification steps. Cutting the context window too aggressively risks truncating the very agentic behavior that makes this model different from a standard chat model. For agentic workloads like scientific simulation or multi-agent fact-checking, it’s worth testing where the model’s orchestration quality starts to degrade before locking in a smaller window.
What makes Sage A1.5’s training approach different?
Sage A1.5 uses a two-stage training process. First, separate teacher models are trained for distinct domains: long-horizon search, software engineering, ML engineering, and scientific research. Each teacher gets its own training environment, and the best trajectories from each are selected, then run through supervised fine-tuning followed by reinforcement learning.
Second, those domain-specific teachers are merged into a single model through a joint post-training step. This step combines two signals: rewards for reaching correct outcomes, and on-policy distillation, where the teacher models give token-level feedback on what the merged student model itself generates. The result is one 35B model that inherits skills across all four domains, including the ability to orchestrate sub agents and verify its own evidence while reasoning.
On top of those four domain skills, Intern added two execution layers: orchestration, which delegates parts of a task to parallel sub agents and integrates their results, and verification, which gathers evidence, reviews its own judgment, and adjusts its next action if something doesn’t check out.
How does it perform on real agentic tasks?
In testing through Hermes agent, Sage A1.5 was given a physics simulation task: model a spacecraft’s gravity assist around Jupiter, check the simulated speed gain against the analytic prediction, and produce an animated HTML visualization. After more than an hour of reasoning and four tool calls across different sub agents, the model produced a working Python simulation. Its simulated result (9.996 km/s) matched the analytic prediction exactly, and it generated a functioning animated HTML file showing the flyby from both Jupiter’s frame and relative to the sun.
A second test asked the model to fact-check astrology by delegating work to three parallel sub agents: one checking actual planetary positions, one assessing gravitational pull claims, and one modeling why vague predictions feel accurate (a statistical cold-reading analysis). The model ran all three sub agents in parallel, verified their outputs against each other, and compiled a single report, including a specific claim that roughly 47% of people find two or more vague predictions convincing purely by chance.
A third test asked the model to act as a forensic physicist, analyzing a photo for seat belt physics, estimated time, season, and region, then ranking hypotheses with probabilities. The model worked through the reasoning in order, showed correct math with stated assumptions, attached confidence percentages to its guesses, and explicitly noted what it couldn’t determine from the image. That last point matters: hallucination control, where the model admits uncertainty rather than fabricating specifics, was consistent across the test.
Is Sage A1.5 worth running locally?
For anyone doing agentic research work, scientific simulation, or multi-step coding tasks, Sage A1.5 is a reasonable candidate for local deployment specifically because its VRAM footprint (around 38GB in testing) puts it within reach of a single high-end GPU, unlike many larger dense models that require multi-GPU clusters. Benchmark comparisons referenced alongside the model placed it ahead of several well-known larger models in its class, though independent verification on your own tasks matters more than any benchmark table.
The tradeoffs are time and context management. The Jupiter gravity assist task took over an hour of reasoning and multiple tool calls, which is expected for a model built around deep, verified multi-step work rather than fast single-turn answers. If your use case needs quick responses rather than deep agentic orchestration, a smaller or faster model will likely serve you better. If you need a model that checks its own math, delegates to sub agents, and flags uncertainty instead of guessing, Sage A1.5’s design is built for exactly that.
Frequently Asked Questions
What hardware do I need to run Sage A1.5 locally?
Based on observed VRAM usage of around 38GB through llama.cpp, a single GPU with 48GB of VRAM (such as an RTX 6000 Ada or A6000) handles it comfortably. Dual 24GB consumer GPUs running together can also work, and lowering the context window reduces the requirement further.
Is Sage A1.5 a dense model or mixture of experts?
It’s a mixture of experts (MoE) model with 35 billion total parameters, built on Qwen 3.6. MoE architectures activate only a subset of parameters per token, which is part of why it runs with less VRAM than a dense model of similar size.
What is Sage A1.5 best suited for?
It’s designed for agentic research and engineering tasks: deep search, scientific analysis, and software engineering, with a particular emphasis on scientific and research-oriented workflows rather than general chat use.
Does reducing the context window hurt performance?
It can. Sage A1.5’s strength is long-horizon, multi-step reasoning with orchestration and verification across sub agents. Shrinking the context window saves VRAM but risks cutting into the extended reasoning chains the model relies on for its agentic behavior.
How does Sage A1.5 compare to other models in benchmarks?
Benchmarks referenced alongside the model’s release showed it ahead of several larger named models in its class. These figures come from the model’s own reported comparisons, so independent testing on your specific workload is the best way to confirm real-world performance.
