Inside Hura: the model that runs every agent

By Pavlo Chabanov — founder of Snaga.

For most of this platform's life, the intelligence inside your agents came from someone else's servers. You wrote a prompt, it left our infrastructure, it was decrypted and read in cleartext on a machine we didn't own, and an answer came back. That arrangement works — until you start caring about where your data goes, what it costs at the scale of agents that never sleep, and who can change the rules underneath you.

Today every agent on Snaga runs on Hura — a model we operate end to end, on hardware we control. This is the technical story of what Hura is, and why we rebuilt the platform's foundation around it.

---

A mixture of experts, not a monolith

Hura is a mixture-of-experts model. A conventional "dense" model of comparable quality pushes every token through every one of its parameters — you pay the full weight of the network for each word it reads and writes. A mixture-of-experts model instead routes each token to a small subset of specialized sub-networks. Hura carries roughly 35 billion parameters in total but activates only about 6 billion for any given token.

That ratio is the whole point. You get the reasoning quality that comes with a large parameter count, at the serving cost and latency of a model a fraction of the size. For an agent platform this is not a nicety — it is the thing that makes the platform economically possible at all.

Agents are relentless. A single task is rarely one model call; it is a loop — read a file, reason about it, call a tool, read the result, decide again — that can run for dozens of turns. Dense large models make that loop slow and expensive enough that you start rationing thought: shorter context, fewer steps, cheaper fallbacks. Mixture-of-experts gives us the headroom to let an agent actually think between actions without the meter spinning out of control.

A window wide enough to hold the work

Hura runs with a 262,144-token context window — roughly a quarter of a million tokens the model can hold in view at once.

Context is the working memory of an agent. It has to fit the conversation so far, the files it has opened, the output of the tools it has run, and the instructions that shape its behavior — all at the same time. When that window is small, the platform is forced to compress and forget: truncate the history, drop the older tool results, summarize away detail the agent may still need. Every one of those compressions is a chance to lose the thread.

A window this wide means an agent can keep a long session, a large document, or a sprawling codebase in mind without the platform quietly amputating half of it to fit. Less forgetting, fewer of the subtle failures that come from an agent acting on a half-remembered picture of its own task.

Reasoning, but only when it earns its keep

Hura reasons before it acts. Given a hard, multi-step problem, it works through the problem internally before committing to an answer or a tool call — the difference between a considered move and a reflex.

But reasoning is not free, and not every message deserves it. A greeting does not need a chain of thought; a request to refactor a module does. A large part of tuning Hura for agent work was teaching it when to think — to spend its reasoning budget on the turns that are genuinely hard and answer directly on the ones that aren't. An agent that deliberates over "hello" is as broken, in its own way, as one that fires off a destructive command without a second thought. Getting that judgment right is most of what separates a model that is technically capable from one that is pleasant to actually run a business on.

The numbers

Speed is not a vanity metric on an agent platform. It is the difference between an agent that can afford to think between every step and one that makes you wait for each one. So here is what Hura actually does, measured over our production serving path in July 2026 — not a lab loopback, and not a figure read off someone else's slide:

• ~164 tokens per second, sustained. Measured single-stream, the decode rate held between 163 and 165 tokens per second across every run, at both 256- and 512-token generations. The consistency matters as much as the peak: an agent loop is only as predictable as the model underneath it.
• ~0.8 seconds to first token. The time from sending a request to the first token arriving — reasoning included, since Hura begins by thinking. This figure carries the real network hop of our production path, not an idealized localhost number.
• A full 256-token answer in about 2.3 seconds; 512 tokens in about 4.1 seconds.

The method is deliberately boring: several warm requests per configuration, the median reported, default serving settings. These are serving numbers — how fast Hura generates — and nothing more. We are not quoting quality-leaderboard scores here, because we did not run those ourselves, and this journal does not publish numbers it cannot stand behind.

That steady ~164 tokens per second is the mixture-of-experts payoff stated as a single figure: generation this consistent, from a model this capable, is exactly what activating six billion parameters instead of thirty-five is for.

Self-hosted, on purpose

We run Hura ourselves, on our own machines. That is a deliberate architectural choice, and it buys four things that matter more the longer you operate a platform:

• Privacy. Your prompts, your files, your agents' internal reasoning — none of it leaves infrastructure we control. There is no third party in the path to decrypt and read it. The most direct way to guarantee your data is not sitting in someone else's logs is for it never to reach them.
• Control. We decide which model your agents run, which version, and how it behaves. No vendor deprecates it from under us, silently changes its behavior between one week and the next, or rate-limits us at the worst possible moment.
• Economics. Agents run around the clock. At that volume, per-token billing to an outside provider is not a line item — it is the business. Owning the serving stack turns a variable cost that scales with every thought your agents have into a fixed one we can plan around.
• No lock-in. The platform's core intelligence is not rented. It cannot be taken away, repriced, or made a lever against us.

Where this sits in the bigger picture

Running the model ourselves removes the third party from the path — a real and immediate privacy gain. It is also the foundation the deeper work stands on. We have written before about the direction toward end-to-end confidential inference — a cryptographic guarantee grounded in Ada and SPARK, where even the machine doing the computing cannot read what it computes on. Self-hosting is not that guarantee by itself; it is the ground you have to own before you can build it. You cannot make inference confidential on hardware you do not control.

What it powers

Every agent on Snaga now runs on Hura. The Head Agent you write to like a notebook, the specialists it delegates to, the background workers, the company loops that keep running while you sleep — one model, tuned for this platform, serving all of it.

That uniformity is a feature. It means the behavior you learn to expect from one agent holds across all of them, and that every improvement we make to how Hura reasons, when it thinks, and how it handles tools lifts the entire platform at once.

What's next

Hura is the largest piece of the stack we have brought in-house, but it is not the last. The direction is consistent: move the parts that matter most — the intelligence, and eventually the confidentiality guarantee around it — onto ground we own, and keep tuning them for the one thing this platform is for. Not a chatbot. A team of agents you can actually trust with the work.