Agents-A1: A 35B Model Built for Long-Horizon Agent Work

A new 35B fine-tune has landed on Hugging Face from InternScience, called Agents-A1. It's built on the Qwen3.5-35B base, and early reports say its tool calling is clearly sharper than that base model. Instruction following is described as very precise, in some comparisons even ahead of Ornith 35B. It also handles vision inputs, and Multi-Token Prediction (MTP) works with both NVFP4 and Q4 quantized builds. The accompanying paper explains why it behaves this way, and the explanation matters for anyone running agents locally.

Scaling the horizon instead of the parameter count

For a while the field has chased size. Kimi-K2.6 reached 1 trillion parameters, and DeepSeek-V4-Pro followed. The working assumption was that more parameters mean a smarter model.

Agents-A1 goes another way. Rather than growing to a trillion parameters, it grows what the paper calls agent horizon: how far a model can carry a complex workflow from the first step to the last without losing the thread.

A verification task shows the idea. Hand an agent running on this model a table of GPU benchmark figures and ask it to double-check the numbers. A long-horizon model searches for each figure, cross-references sources, flags inconsistencies and can even correct a value that was copied from a stale cached page. No step-by-step instructions are needed, because the model treats the job as unfinished until every number is confirmed.

Short horizon versus long horizon, side by side

Benchmark tables hide how different these two styles feel in use, so a concrete case helps. The example below is an illustration of the pattern, not a measured result.

Take this request: research current GPU prices, compare the RTX 5090 with the R9700 across three retailers, check availability, and say which offers better value for local AI inference.

A conventional short-horizon LLM tends to behave like this:

- Generates a generic comparison table from training data
- Lists typical specs and MSRP prices
- Done in ~800 tokens

The reply is tidy and roughly accurate, but it comes from memory. The research that was requested never happened.

A long-horizon agent model works differently:

Step 1: [Reasoning] "Need to check current GPU pricing across multiple retailers"
        → Action: Search Amazon for RTX 5090 listings

Step 2: [Observation] Found RTX 5090 at $4,500-$5,000 range, limited stock

Step 3: [Reasoning] "Now check AMD R9700 pricing and availability"
        → Action: Search Newegg for R9700 Creator listings

Step 4: [Observation] R9700 at $1,340 with better local AI benchmarks per GB

Step 5: [Reasoning] "Cross-reference with local inference performance data..."
        → Action: Pull benchmark comparisons from available sources
... (continues through 8+ steps)
Total trajectory: ~12,000 tokens across multiple search cycles, reasoning steps, and cross-referenced conclusions

One model makes a call or two and answers. The other keeps acting on the request. Agents-A1 doesn't end once text is generated. It reasons about what needs doing, acts, observes results, adjusts when something goes sideways, and continues until the job is done.

How it scores

Here's the comparison against Qwen3.6-27B, Claude Opus 4.8 and GPT-5.4, drawn from the paper and public benchmark pages:

| Benchmark                | Agents-A1   | Qwen3.6-27B | Opus 4.8  | GPT-5.4     | Winner        |
|--------------------------|-------------|-------------|-----------|-------------|---------------|
| SEAL-0                   | **56.4** ✅ | 44.1        | 54.95     | Not reported| Agents-A1     |
| IFBench                  | **80.6** ✅ | 76.1        | Not tested| 75.9        | Agents-A1     |
| SWE-bench Verified       | Not tested  | **77.2** ✅ | 80.9      | Not reported| Qwen3.6-27B   |
| Terminal-Bench 2.0       | Not tested  | **59.3** ✅ | 59.3      | Not reported| Qwen3.6-27B   |
| BrowseComp               | **75.51** ✅| Not tested  | Not tested| 83.4        | Agents-A1     |
| GPQA Diamond             | Not tested  | **87.8** ✅ | 87.0      | Not reported| Qwen3.6-27B   |
| LiveCodeBench v6         | Not tested  | **83.9** ✅ | 84.8      | Not reported| Qwen3.6-27B   |
| HiPhO                    | **46.4** ✅ | Not tested  | 43.3      | Not reported| Agents-A1     |
| FrontierScience-Olympiad | **79.0** ✅ | Not tested  | 78.0      | Not reported| Agents-A1     |

The numbers break down by skill.

• Long-horizon search and research. SEAL-0 shows a gain of 12.3 points over Qwen3.6-27B, and it even edges past Opus 4.8, which sits at 54.95. The benchmark measures how well a model gathers information over many steps without drifting.
• Instruction following. On IFBench it adds 4.5 points over both Qwen3.6-27B and GPT-5.4 (75.9). With a prompt carrying several constraints, it satisfies all of them, not just the first one it grasps.
• Browsing agents. BrowseComp comes in at 75.51. That means navigating real sites, pulling data out, coping with dynamic content, and adapting when a page loads differently than expected. The top score belongs to GPT-5.4 with 83.4, yet Agents-A1 trails by under 8 points at about one twentieth of the size.
• Scientific reasoning and planning. On HiPhO, a long-horizon planning test, and on FrontierScience-Olympiad it finishes ahead of Opus 4.8, though only by a few points each time. Research workflows that chain reasoning across several domains stand to gain the most from that.

If these figures hold up, the lesson is that a 35-billion-parameter model trained well can outthink much larger ones. It doesn't win by knowing more. It wins by thinking further.

Why it matters on local hardware

Running models on consumer machines comes with familiar limits:

• A normal PC case can't hold an 8-GPU rig.
• Cloud inference costs pile up quickly when an agent makes dozens of API calls per task.
• A bigger model isn't automatically a better agent. It often just costs more to run.

Agents-A1 shifts that trade. With 35B parameters and a Mixture-of-Experts design, it runs comfortably on something like a MacBook while reaching agentic performance that approaches Opus-level results on certain benchmarks. Think of a marathon runner who isn't faster in a sprint than anyone else but won't quit when everybody else does.

Where to get it

Progress at the 35B size keeps coming, and the pattern points toward smarter training beating brute-force scaling, particularly for agentic workloads where horizon counts for more than raw parameter count. Two community GGUF conversions are available.

The NVFP4 build that includes MTP:

https://huggingface.co/s-batman/Agents-A1-NVFP4-MTP-GGUF

Regular GGUF quants:

https://huggingface.co/LordNeel/Agents-A1-GGUF

Both load in llama.cpp. The NVFP4 build with MTP speeds up token generation on compatible hardware, while the standard files give more flexibility across inference setups.

Later notes

• As of July 2, 2026, Qwen3.6-27B remains the most balanced and capable model for coding work.
• As of July 8, 2026, Agents-A1 is clearly stronger at research. It searches across wider and broader topics and produces better results.

Further reading: the arXiv paper "Scaling the Horizon, Not the Parameters" (2606.30616) and the InternScience/Agents-A1 page on Hugging Face.