The Agent Model Is a Deployment Budget

The Agent Model Is a Deployment Budget

A 30B model is not necessarily a 30B-per-token deployment.

KRAFTON’s Raon-1 mini preview is described as a 30B-A4B mixture-of-experts model. Its model card reports 28.8B total parameters and 4.3B activated parameters per token, with open weights under Apache 2.0.

That is the product announcement. The systems lesson is more useful: the model you deploy is a budget for an entire agent loop, not just a checkpoint loaded into memory.

The headline number hides the operating cost

A dense model makes parameter count a rough proxy for compute. Sparse routing breaks that shortcut.

Raon-1 mini has 128 routed experts, but the model card says only six routed experts and one shared expert are active for each token. The result is a large pool of capacity with a smaller per-token path.

The architecture also uses a hybrid attention design. The model card reports 18 Raon Delta Attention layers and seven gated MLA layers. Most layers use a fixed-size recurrent state, while the MLA layers retain a KV cache. KRAFTON says the model supports a 262,144-token context window.

Those details are not trivia. They describe the resources an operator must provision:

Deployment propertyRaon-1 mini previewWhy an agent builder cares
Total parameters28.8BWeight storage and loading cost
Activated parameters4.3B per tokenApproximate per-token compute budget
Context length262,144 tokensRoom for tool results and long tasks
Active experts6 routed plus 1 sharedSparse routing behavior
QuantizationNVFP4, MXFP8 and BF16 artifacts listedHardware and latency choices
LicenseApache 2.0 for the weightsDeployment and modification freedom

The model card says an NVFP4 build can run on a single NVIDIA RTX 5090 with 32 GB of VRAM. That is a published deployment claim, not an independent reproduction. The real result will depend on runtime, batch size, context length, quantization, and the tool loop wrapped around the model.

Agent quality is a control-loop property

KRAFTON positions Raon-1 mini for agent execution and lists support for Hermes Agent, Pi, and OpenCode. The official page also says the model was built for precise instruction following and multi-step tasks.

The model card publishes results for coding, search, and agentic benchmarks. It reports 70.8 on SWE-Verified and 55.7 on BrowseComp Plus. It also reports 59.8 on BFCL v4 overall, a function-calling benchmark.

These are KRAFTON’s results, using the evaluation setup described in the model card. They support a bounded conclusion: the release is aimed at the tool-use loop, not only at chat quality. They do not prove that it will be the best model for every coding agent or every workload.

The useful evaluation target is the complete loop:

model proposes action
        |
        v
harness validates tool call
        |
        v
bounded runner executes it
        |
        v
tool result returns to context
        |
        +------ model chooses next action

A model that produces valid tool calls but loses state after a long result is not reliable. A model that reasons well but emits malformed arguments creates recovery work. A model that is fast in an isolated benchmark but stalls when the context contains logs, diffs, and failed tool results may be a poor local agent.

The model is one component in the control loop. The harness determines whether its capabilities become useful behavior.

The context window is not free memory

A 262K context window sounds like a straightforward advantage for agents. Long context can hold more code, logs, tool outputs, and conversation history. It can also increase the amount of irrelevant or adversarial material the model must interpret.

The operator should treat context as a managed resource, not an infinite scratchpad.

A long-running agent needs policies for:

  • truncating stale tool output
  • summarizing completed sub-tasks
  • separating instructions from untrusted repository content
  • marking which files and results are authoritative
  • limiting how much a tool can inject into the next decision
  • preserving a compact audit trail outside the model context

The uncomfortable truth is that a larger context window can make a weak control loop harder to inspect. More tokens do not automatically produce better state management. They can make prompt injection, memory poisoning, and accidental instruction mixing persist for longer.

The right question is not whether the model accepts 262K tokens. It is whether the harness can decide what deserves to occupy those tokens.

Open weights move the boundary inward

KRAFTON’s release makes the weights available under Apache 2.0, while its hosted API and playground have separate access terms. The distinction matters.

With local weights, the operator controls more of the deployment surface: the inference runtime, model files, network boundary, logging path, and update process. That can reduce provider dependency and keep sensitive code inside the operator’s environment.

It also transfers responsibility inward.

A local model process should not automatically receive the same permissions as the agent harness. The tool runner still needs explicit filesystem scope, network controls, approval gates for high-impact actions, and an audit trail. Downloaded model files remain supply-chain inputs. A permissive license is not a trust attestation.

The safe architecture is still layered:

open weights
    |
    v
local inference process
    |
    v
agent harness and policy verifier
    |
    v
least-privilege tool runner
    |
    v
isolated workspace and auditable side effects

The model proposes. The verifier decides. The runner executes within a scope the model cannot expand for itself.

What changed for operators

Raon-1 mini is another sign that open agent models are being optimized around deployment constraints rather than model size alone.

The important measurements are now distributed across the system:

  1. Active compute: how much work each token requires.
  2. Memory behavior: how attention, recurrent state, and context affect the target device.
  3. Tool-loop fit: whether the model can make, recover from, and sequence real tool calls.
  4. Control surface: whether the local harness keeps model output separate from authorization.
  5. Operational cost: how much latency, storage, and maintenance the complete loop consumes.

The release is a preview, and the model card explicitly says its specifications and results may change before the final model. That caveat is important. A preview benchmark is a starting point for a deployment test, not a deployment decision.

The model you choose sets the budget. The architecture decides what that budget buys you.

Sources

Keep reading