The future of AI is small, local, and efficient. And the data is starting to prove it.

On long-horizon agentic benchmarks, open-weight models with the right harness and task-specific tuning are posting 20+ point gains over frontier baselines. Not a marginal edge. Twenty-plus points, on the work that actually runs in production: agents calling tools, orchestrating workflows, operating autonomously for hours.

The number is concrete, not hand-waved. WebRL, a curriculum reinforcement learning framework out of Tsinghua and Zhipu, took the open GLM-4-9B from 6.1% to 43.0% on WebArena-Lite, clearing GPT-4-Turbo at 17.6% and GPT-4o at 13.9%. Same benchmark. A model a fraction of the size. And it wins.

Where frontier models still win (and why that isn’t the point)

Frontier models are still superior for narrow, high-complexity reasoning. Legal analysis. Deep research. Specialist inference. The hard, single-shot problems where one brilliant answer is worth almost any price. Nobody serious is disputing that.

Paolino Madotto nailed this in Agenda Digitale: the value of AI is shifting from the model itself to the system that orchestrates it. In a well-designed system, the frontier model is not the engine running every token of an hour-long agent loop. It’s the premium specialist the orchestrator calls, selectively, when a problem genuinely demands it.

That’s frontier’s rightful place: the expensive expert on retainer, not the machine you leave running all day.

And notice where the leverage actually sits. Harness engineering alone (the loop, the tools, the retry logic, the verification wrapped around a fixed model) can buy 10-15 points on some agentic benchmarks without touching the weights. The scaffold is doing the work. Which is exactly why the model you drop into that scaffold can be smaller, cheaper, and yours.

The metric almost nobody is measuring

Everyone quotes cost per token. Almost nobody making the actual buy-or-build decision measures watts per token: energy per token. That’s the number I keep coming back to, because it’s the one that decides whether an agentic system survives contact with scale.

The researchers are starting to catch up. Stanford’s Hazy Research group calls it intelligence per watt, and their numbers point the same way: IPW improved 5.3x in two years (3.1x from better small models, 1.7x from hardware), and local models already handle 88.7% of single-turn chat and reasoning queries. The trend line isn’t subtle.

Here’s the math that matters.

A long-running agent doesn’t emit a few thousand tokens. It loops. It retries. It calls tools and reasons over the results for hours. It burns millions of tokens per task, per run, per user. Multiply watts per token by that volume, across a fleet of agents in production, and energy stops being a footnote on the invoice. It becomes the business case. Or the reason the business case collapses.

Frontier APIs were priced for the era of the single clever answer. Agentic workloads live in a different regime entirely: enormous token volume, most of it routine orchestration that doesn’t need a frontier brain. Paying frontier rates for that volume, in dollars and in watts, isn’t a strategy. It’s a leak.

Why the token economics don’t hold

Current token economics break at agentic scale. Not because API prices are high today, but because prices and physics obey different laws. Prices can drop: they’re a margin decision. Joules per token have a floor, and that floor is set by model size. Every token a trillion-parameter model generates costs far more energy than the same token from a 9B model, no matter whose datacenter runs it.

And let’s be honest about the fine print: the watts-per-token win doesn’t come from the server’s zip code. A local GPU idling at 30% utilization can burn more energy per token than a hyperscaler’s batched fleet. The win comes from right-sizing the model to the task and keeping the hardware busy. What local adds is the thing no API can sell you: complete data sovereignty, not a single byte leaving the building.

Right model. Right task. Right infrastructure.

That’s not a compromise. That’s good engineering.

Where this leaves security (and where HikmaAI comes in)

Owning the full stack means owning the full stack. That includes the security layer. Here’s the part too many “go local” arguments skip.

The moment you bring models in-house and let agents operate autonomously, you bring the entire security and governance burden in-house with them. A frontier API at least ships with the provider’s guardrails baked in. An open-weight model you run yourself has none of that by default. And an agent that calls tools and acts for hours is a far larger attack surface than a single chat completion. Prompt injection, goal hijacking, PII leakage, tool misuse: these scale with autonomy. That’s the hidden tax on the watts you just saved.

Going local doesn’t shrink the need for a security platform. It multiplies it. That’s the problem we built HikmaAI for.

HikmaAI is platform-agnostic by design. It scans and evaluates your models and your agents (Ollama, OpenAI, or your own REST API; proprietary or open-weight; cloud, on-prem, or hybrid) for security vulnerabilities, prompt injection, toxicity, PII exposure, and compliance gaps, with adaptive red teaming and guardrails for the systems you now own end to end.

And it does it without breaking the promise that made you go local in the first place: your data stays on European infrastructure, no source code leaves your environment, nothing crosses a border it shouldn’t. The same sovereignty argument that drives the move to local models is the argument for governing them with a platform built around sovereignty from the ground up.

Small, local, efficient, and secured. That’s the full stack.

Right model. Right task. Right infrastructure. Right guardrails.

— Mauro

References:

• Paolino Madotto, “Il vero valore dell’AI non è più nel modello, ma nel sistema che lo guida,” Agenda Digitale.
• Qi et al., “WebRL: Training LLM Web Agents via Self-Evolving Online Curriculum Reinforcement Learning,” arXiv:2411.02337.
• Saad-Falcon, Narayan et al., “Intelligence Per Watt: A Study of Local Intelligence Efficiency,” Stanford Hazy Research, blog / arXiv:2511.07885.