Introducing Krun One V1: Multimodal Decisions at System-One Speed

Today we're introducing Krun One V1, the next generation of our decision model.

Krun One started with a simple idea: most applications do not need a large generative model for every semantic decision.

Sometimes software just needs to answer questions like:

• Which option best matches this request?
• Does this condition apply?
• How strong is this signal?
• Which labels are present?
• What should happen next?

Krun One V1 expands that idea beyond text.

The new model can make structured decisions over text, images, documents, and audio, while preserving the same core philosophy: fast inference, typed outputs, probabilities, and application-controlled workflows.

One model, multiple modalities

Krun One V1 supports:

Text
Images
Documents
Audio

Applications can also combine them in the same decision.

For example, a request can include an instruction together with an uploaded document:

{
  "context": [
    {
      "type": "text",
      "text": "Classify this document."
    },
    {
      "type": "document",
      "asset_id": "asset_123"
    }
  ]
}

The output remains structured.

Krun does not generate another document, image, or audio response. It turns multimodal context into decisions your code can immediately consume.

Four decision primitives

Krun One V1 supports four primitives:

Choice

Select one answer from a known set.

billing
technical
sales
account

Noul

Estimate whether a condition holds.

Does this request require human review?

Score

Evaluate something along an ordered semantic dimension.

low
medium
high
critical

Multi

Select multiple labels when more than one can apply.

{
  "values": ["billing", "refund"],
  "probabilities": {
    "billing": 0.97,
    "refund": 0.91
  }
}

These primitives are designed to be composed by application code rather than replacing the application itself.

Multimodal without pushing complexity to developers

One of our goals with V1 was to keep multimodal processing out of application code.

Developers should not need to build separate OCR, speech transcription, and vision pipelines just to make a decision.

Krun One handles modality routing internally.

For documents with a text layer, it can use the extracted text directly.

For scanned documents and screenshots, the runtime can combine OCR and visual understanding.

For audio, it uses both speech transcription and acoustic representations.

The application provides the context.

Krun decides how that context should be processed.

Application
    ↓
Krun
    ├── text
    ├── vision
    ├── OCR
    └── audio
         ↓
structured decision

The text path stays fast

Adding multimodality should not make ordinary text decisions expensive.

Krun One V1 loads multimodal components lazily.

A text-only request does not need to initialize the vision, OCR, or audio stack.

That lets us preserve the characteristics that made Krun useful in the first place: low-latency semantic decisions inside normal application code.

In our current internal benchmarks, the new text path is running in roughly the 15–20 ms inference range on our target hardware.

End-to-end API latency depends on networking and serving infrastructure, but keeping the model itself fast gives us room to optimize the rest of the stack aggressively.

Built for software, not chat

Krun One is not a chatbot.

It is not designed to write essays, generate images, or produce long reasoning traces.

It is designed to sit inside software.

request
   ↓
semantic decision
   ↓
typed result + probabilities
   ↓
application logic

That makes it useful for workflows such as:

• routing
• classification
• moderation
• verification
• ranking
• document intake
• support automation
• risk assessment
• agent and tool selection
• human-review escalation
• multimodal triage

A generative model can still be part of the same system.

Krun can decide when that larger model is necessary, route work to it, or verify bounded properties of its output.

Backward compatible by design

Existing text integrations remain valid.

The current string-based context format continues to work:

{
  "context": "Classify this support request."
}

Multimodal context is additive rather than a replacement.

That means applications can adopt the new capabilities incrementally instead of rewriting their existing Krun integration.

What's next

The model runtime and multimodal artifact are now complete.

We are currently finishing the integration into Krun's serving and asset infrastructure, including upload handling, authorization, SDK support, latency testing, and production rollout validation.

Our goal is not simply to make Krun multimodal.

It is to make multimodal semantic decisions feel like another programming primitive:

fast
typed
probabilistic
composable

Krun One V1 is the foundation for that.